home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / program / ddj0897.zip / DYN401.ZIP / dpp / proto.c < prev    next >
C/C++ Source or Header  |  1997-04-16  |  14KB  |  541 lines
  1.  
  2.  
  3. /*  Copyright (c) 1993-1996 Algorithms Corporation  */
  4. /*  All rights reserved.  */
  5.  
  6.  
  7.  
  8.  
  9. /*  This file automatically generated by dpp - do not edit  */
  10.  
  11. #define    DPP_STRATEGY    2
  12. #define    DPP_FASTWIDE    0
  13.  
  14.  
  15.  
  16. #line 16 "proto.d"
  17. #include <ctype.h> 
  18. #include <string.h> 
  19.  
  20. #include "dpp.h" 
  21.  
  22. #define    CLASS    Prototype_c
  23. #define    ivType    Prototype_iv_t
  24.  
  25. #include "generics.h"
  26.  
  27. object    Prototype_c;
  28.  
  29.  
  30. #line 31 "proto.c"
  31. typedef struct  _Prototype_iv_t  {
  32.     object iName;
  33.     object iFixedName;
  34.     object iRtn;
  35.     object iArgs;
  36.     object iProto;
  37.     object iParams;
  38.     int iVararg;
  39.     int iException;
  40.     int iNeedRest;
  41.     object iLastArg;
  42. }    Prototype_iv_t;
  43.  
  44.  
  45. #line 36 "proto.d"
  46. #define strne(a, b) strcmp(a, b) 
  47. #define streq(a, b) !strcmp(a, b) 
  48.  
  49. #define istart(x) (isalpha(x) || (x) == '_') 
  50. #define irest(x) (isalnum(x) || (x) == '_') 
  51.  
  52.  
  53. extern char *trunc_mname(char *mname); 
  54.  
  55.  
  56. cmeth objrtn Prototype_cm_gNew(object self)
  57. { 
  58.     return gShouldNotImplement(self, "gNew"); 
  59. } 
  60.  
  61. cmeth objrtn Prototype_cm_gNewWithStrStr(object self, char *nm, char *rt)
  62. { 
  63.     object obj = oSuper(Prototype_c, gNew, self)(self); 
  64.     ivType *iv = ivPtr(obj); 
  65.     iv->iName = gNewWithStr(String, nm); 
  66.     iv->iRtn = gNewWithStr(String, rt); 
  67.     return obj; 
  68. } 
  69.  
  70. imeth objrtn Prototype_im_gDispose(object self)
  71. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  72.     gDispose(iv->iName); 
  73.     if (iv->iFixedName) 
  74.         gDispose(iv->iFixedName); 
  75.     gDispose(iv->iRtn); 
  76.     if (iv->iArgs) 
  77.         gDeepDispose(iv->iArgs); 
  78.     if (iv->iProto) 
  79.         gDeepDispose(iv->iProto); 
  80.     if (iv->iParams) 
  81.         gDeepDispose(iv->iParams); 
  82.     if (iv->iLastArg) 
  83.         gDeepDispose(iv->iLastArg); 
  84.     return oSuper(Prototype_c, gDispose, self)(self); 
  85. } 
  86.  
  87. imeth int Prototype_im_gHash(object self)
  88. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  89.     return gHash(iv->iName); 
  90. } 
  91.  
  92. imeth int Prototype_im_gCompare(object self, object obj)
  93. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  94.     ChkArgTyp(obj, 2, CLASS); 
  95.     return gCompare(iv->iName, ivPtr(obj)->iName); 
  96. } 
  97.  
  98. static void remove_variable(char *buf, char *var) 
  99. { 
  100.     register int i, vi = -1; 
  101.  
  102.     for (i=0 ; buf[i] ; ) 
  103.         if (istart(buf[i])) { 
  104.         vi = i++; 
  105.         while (buf[i] && irest(buf[i])) 
  106.             i++; 
  107.     } else 
  108.         i++; 
  109.  
  110.     if (vi >= 0) { 
  111.         for (i=vi ; irest(buf[i]) ; ) 
  112.             *var++ = buf[i++]; 
  113.         if (vi && buf[vi-1] == ' ') 
  114.             vi--; 
  115.         for (i=vi+1 ; buf[i] && irest(buf[i]) ; i++); 
  116.         memmove(buf+vi, buf+i, strlen(buf+i) + 1); 
  117.     } 
  118.     *var = '\0'; 
  119. } 
  120.  
  121. static void make_proto(ivType *iv, object ar) 
  122. { 
  123.     object seq, nxt, prv=NULL; 
  124.     char buf[100], var[50]; 
  125.  
  126.     iv->iProto = gNew(LinkObject); 
  127.     iv->iParams = gNew(LinkObject); 
  128.     for (seq=gSequence(ar) ; nxt = gNext(seq) ; ) { 
  129.         strcpy(buf, gStringValue(nxt)); 
  130.         remove_variable(buf, var); 
  131.         gAddLast(iv->iProto, gNewWithStr(String, buf)); 
  132.         if (!*var) { 
  133.             iv->iNeedRest = 1; 
  134.             if (iv->iLastArg) 
  135.                 DISPOSE(iv->iLastArg); 
  136.             iv->iLastArg = prv ? gCopy(prv) : prv; 
  137.         } 
  138.         gAddLast(iv->iParams, prv=gNewWithStr(String, *var ? var : "_rest_")); 
  139.     } 
  140. } 
  141.  
  142. imeth objrtn Prototype_im_gPrintArgs(object self, object fobj)
  143. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  144.     object seq, nxt; 
  145.     int n=0; 
  146.  
  147.     if (iv->iArgs && !iv->iVararg && !iv->iException) 
  148.         for (seq=gSequence(iv->iArgs) ; nxt = gNext(seq) ; ) { 
  149.         if (n++) 
  150.             gPuts(fobj, ", "); 
  151.         gPuts(fobj, (char *) nxt); 
  152.     } 
  153.     else 
  154.         gPuts(fobj, "object self, ..."); 
  155.     return self; 
  156. } 
  157.  
  158. imeth objrtn Prototype_im_gPrintFixedArgs(object self, object fobj)
  159. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  160.     object seq, nxt; 
  161.     int n=0; 
  162.  
  163.     if (iv->iArgs) 
  164.         for (seq=gSequence(iv->iArgs) ; nxt = gNext(seq) ; ) { 
  165.         if (n++) 
  166.             gPuts(fobj, ", "); 
  167.         gPuts(fobj, (char *) nxt); 
  168.     } 
  169.     else 
  170.         gPuts(fobj, "object self, ..."); 
  171.     return self; 
  172. } 
  173.  
  174. imeth objrtn Prototype_im_gPrintMethArgs(object self, object fobj, int Strategy, int vararg)
  175. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  176.     object seq, nxt; 
  177.     int n=0; 
  178.  
  179.     if (vararg && Strategy != 1) { 
  180.         gPut(fobj, gNewToken(Token, "object self", 0L, 0)); 
  181.         gPut(fobj, gNewToken(Token, ",", 0L, 1)); 
  182.         gPut(fobj, gNewToken(Token, "va_list _rest_", 0L, 0)); 
  183.     } else if (iv->iArgs) 
  184.         for (seq=gSequence(iv->iArgs) ; nxt = gNext(seq) ; ) { 
  185.         if (n++) 
  186.             gPut(fobj, gNewToken(Token, ",", 0L, 1)); 
  187.         if (Strategy > 1 && streq(gStringValue(nxt), "...")) 
  188.             gPut(fobj, gNewToken(Token, "va_list _rest_", 0L, 0)); 
  189.         else 
  190.             gPut(fobj, gNewToken(Token, gStringValue(nxt), 0L, 0)); 
  191.     } 
  192.     gPut(fobj, gNewToken(Token, ")", 0L, 0)); 
  193.     return self; 
  194. } 
  195.  
  196. imeth objrtn Prototype_im_gPrintVars(object self, object fobj)
  197. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  198.     object seq, nxt; 
  199.     int n=0; 
  200.     char *v; 
  201.  
  202.     if (iv->iParams && !iv->iVararg && !iv->iException) 
  203.         for (seq=gSequence(iv->iParams) ; nxt = gNext(seq) ; ) { 
  204.         if (n++) 
  205.             gPuts(fobj, ", "); 
  206.         v = gStringValue(nxt); 
  207.         if (*v) 
  208.             gPuts(fobj, (char *) nxt); 
  209.         else 
  210.             gPuts(fobj, "_rest_"); 
  211.     } 
  212.     else 
  213.         gPuts(fobj, "self, _rest_"); 
  214.     return self; 
  215. } 
  216.  
  217. imeth objrtn Prototype_im_gUseVars(object self, object fobj)
  218. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  219.     object seq, nxt; 
  220.     char *v; 
  221.     int n = 0; 
  222.  
  223.     if (!iv->iParams) 
  224.         return self; 
  225.     for (seq=gSequence(iv->iParams) ; nxt = gNext(seq) ; ) 
  226.         if (n++) { 
  227.         v = gStringValue(nxt); 
  228.         if (*v && strne(v, "_rest_")) 
  229.             vPrintf(fobj, "\tUSE(%s);\n", v); 
  230.     } 
  231.     return self; 
  232. } 
  233.  
  234. #if 0 
  235.  
  236. static void print_args(ivType *iv, object ar) 
  237. { 
  238.     object seq, nxt; 
  239.     int n=0; 
  240.  
  241.     vPrintf(stdoutStream, "%s %s(", gStringValue(iv->iRtn), gStringValue(iv->iName)); 
  242.     for (seq=gSequence(ar) ; nxt = gNext(seq) ; ) { 
  243.         if (n++) 
  244.             gPuts(stdoutStream, ", "); 
  245.         gPuts(stdoutStream, (char *) nxt); 
  246.     } 
  247.     gPuts(stdoutStream, ")\n"); 
  248.     if (iv->iVararg) 
  249.         gPuts(stdoutStream, "Varargs is set\n"); 
  250.     else 
  251.         gPuts(stdoutStream, "Varargs is not set\n"); 
  252.     if (iv->iException) 
  253.         gPuts(stdoutStream, "Exception is set\n"); 
  254.     else 
  255.         gPuts(stdoutStream, "Exception is not set\n"); 
  256. } 
  257.  
  258. #endif 
  259.  
  260. imeth objrtn Prototype_im_gSetArgs(object self, object ar)
  261. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  262.     if (iv->iArgs) 
  263.         DEEPDISPOSE(iv->iArgs); 
  264.     if (iv->iProto) 
  265.         iv->iProto = DEEPDISPOSE(iv->iProto); 
  266.     if (iv->iParams) 
  267.         iv->iParams = DEEPDISPOSE(iv->iParams); 
  268.     if (iv->iArgs = ar) 
  269.         make_proto(iv, ar); 
  270.     if (ar && gSize(ar) == 2 && streq(gStringValue(gLast(ar)), "...")) 
  271.         iv->iVararg = 1; 
  272. #if 0 
  273.         print_args(iv, iv->iArgs); 
  274.     print_args(iv, iv->iProto); 
  275. #endif 
  276.         return self; 
  277. } 
  278.  
  279. imeth objrtn Prototype_im_gReturnType(object self)
  280. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  281.     return iv->iRtn; 
  282. } 
  283.  
  284. imeth objrtn Prototype_im_gArgs(object self)
  285. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  286.     return iv->iArgs; 
  287. } 
  288.  
  289. imeth objrtn Prototype_im_gPrototype(object self)
  290. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  291.     return iv->iProto; 
  292. } 
  293.  
  294. imeth objrtn Prototype_im_gParameters(object self)
  295. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  296.     return iv->iParams; 
  297. } 
  298.  
  299. imeth objrtn Prototype_im_gDeepCopy(object self)
  300. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  301.     object nobj; 
  302.     ivType *niv; 
  303.  
  304.     nobj = oSuper(Prototype_c, gDeepCopy, self)(self); 
  305.     niv = ivPtr(nobj); 
  306.     niv->iName = gDeepCopy(iv->iName); 
  307.     niv->iFixedName = iv->iFixedName ? gDeepCopy(iv->iFixedName) : iv->iFixedName; 
  308.     niv->iRtn = gDeepCopy(iv->iRtn); 
  309.     if (iv->iArgs) { 
  310.         niv->iArgs = gDeepCopy(iv->iArgs); 
  311.         niv->iProto = gDeepCopy(iv->iProto); 
  312.         niv->iParams = gDeepCopy(iv->iParams); 
  313.     } 
  314.     if (iv->iLastArg) 
  315.         niv->iLastArg = gDeepCopy(iv->iLastArg); 
  316.     return nobj; 
  317. } 
  318.  
  319. imeth int Prototype_im_gMatchNoError(object self, object mproto)
  320. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  321.     ivType *miv = ivPtr(mproto); 
  322.     object mseq, gseq, garg, marg; 
  323.  
  324. #if 0 
  325.         print_args(iv, iv->iArgs); 
  326.     print_args(miv, miv->iArgs); 
  327. #endif 
  328.  
  329.         if (gCompare(miv->iRtn, iv->iRtn)) 
  330.         return 0; 
  331.  
  332.     if ((!miv->iArgs || miv->iVararg || miv->iException) && (!iv->iArgs || iv->iVararg)) 
  333.         return 1; 
  334.  
  335.     if (miv->iException || !miv->iArgs || miv->iVararg || !iv->iArgs || iv->iVararg) 
  336.         return 0; 
  337.  
  338.     if (gSize(miv->iArgs) != gSize(iv->iArgs)) 
  339.         return 0; 
  340.  
  341.     mseq = gSequence(miv->iArgs); 
  342.     gseq = gSequence(iv->iArgs); 
  343.     garg = (object) 1; 
  344.     while (marg = gNext(mseq)) { 
  345.         garg = gNext(gseq); 
  346.         if (!garg || gCompare(marg, garg)) { 
  347.             DISPOSE(mseq); 
  348.             if (garg) 
  349.                 DISPOSE(gseq); 
  350.             return 0; 
  351.         } 
  352.     } 
  353.     if (garg) 
  354.         DISPOSE(gseq); 
  355.  
  356.     return 1; 
  357. } 
  358.  
  359. imeth int Prototype_im_gMatch(object self, object mproto)
  360. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  361.     ivType *miv = ivPtr(mproto); 
  362.     object mseq, gseq, garg, marg; 
  363.     int n, error=0; 
  364.  
  365. #if 0 
  366.         print_args(iv, iv->iArgs); 
  367.     print_args(miv, miv->iArgs); 
  368. #endif 
  369.  
  370.         if (gCompare(miv->iRtn, iv->iRtn)) { 
  371.         error = 1; 
  372.         vPrintf(stdoutStream, "Method %s and generic %s have different return types\n", 
  373.             trunc_mname(gStringValue(miv->iName)), 
  374.             gStringValue(iv->iName)); 
  375.     } 
  376.  
  377.     if (iv->iException || miv->iVararg && iv->iVararg) 
  378.         return error; 
  379.  
  380.     if (miv->iVararg || iv->iVararg) { 
  381.         vPrintf(stdoutStream, "Method %s and generic %s have different arguments\n", 
  382.             trunc_mname(gStringValue(miv->iName)), 
  383.             gStringValue(iv->iName)); 
  384.         return 1; 
  385.     } 
  386.  
  387.     if (!miv->iProto) { 
  388.         vPrintf(stdoutStream, "Warning: Method %s has no prototype.\n", 
  389.             trunc_mname(gStringValue(miv->iName))); 
  390.         return error; 
  391.     } 
  392.  
  393.     if (!iv->iProto) 
  394.         return error; 
  395.  
  396.     if (gSize(miv->iProto) != gSize(iv->iProto)) { 
  397.         vPrintf(stdoutStream, "Method %s and generic %s have a different number of arguments\n", 
  398.             trunc_mname(gStringValue(miv->iName)), 
  399.             gStringValue(iv->iName)); 
  400.         return 1; 
  401.     } 
  402.  
  403.     mseq = gSequence(miv->iProto); 
  404.     gseq = gSequence(iv->iProto); 
  405.     garg = (object) 1; 
  406.     for (n=1 ; marg = gNext(mseq) ; ++n) { 
  407.         garg = gNext(gseq); 
  408.         if (!garg) { 
  409.             error = 1; 
  410.             vPrintf(stdoutStream, "Method %s and generic %s have a different number of arguments.\n", 
  411.                 trunc_mname(gStringValue(miv->iName)), 
  412.                 gStringValue(iv->iName)); 
  413.             break; 
  414.         } 
  415. #line 409 "proto.d"
  416.         if (gCompare(marg, garg)) { 
  417.             error = 1; 
  418.             vPrintf(stdoutStream, "Method %s and generic %s have different argument types (%d)\n", 
  419.                 trunc_mname(gStringValue(miv->iName)), 
  420.                 gStringValue(iv->iName), n); 
  421.         } 
  422.     } 
  423.     if (marg) 
  424.         DISPOSE(mseq); 
  425.     if (garg) 
  426.         DISPOSE(gseq); 
  427.  
  428.     return error; 
  429. } 
  430.  
  431. imeth objrtn Prototype_im_gGetMGName(object self)
  432. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  433.     return iv->iName; 
  434. } 
  435.  
  436. imeth objrtn Prototype_im_gChangeName(object self, char *nm)
  437. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  438.     if (iv->iName) 
  439.         gChangeStrValue(iv->iName, nm); 
  440.     else 
  441.         iv->iName = gNewWithStr(String, nm); 
  442.     return self; 
  443. } 
  444.  
  445. imeth objrtn Prototype_im_gGetFixedName(object self)
  446. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  447.     return iv->iFixedName; 
  448. } 
  449.  
  450. imeth objrtn Prototype_im_gChangeFixedName(object self, char *nm)
  451. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  452.     if (iv->iFixedName) 
  453.         gChangeStrValue(iv->iFixedName, nm); 
  454.     else 
  455.         iv->iFixedName = gNewWithStr(String, nm); 
  456.     return self; 
  457. } 
  458.  
  459. imeth objrtn Prototype_im_gVarArg(object self)
  460. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  461.     iv->iVararg = 1; 
  462.     return self; 
  463. } 
  464.  
  465. imeth int Prototype_im_gIsVarArg(object self)
  466. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  467.     return iv->iNeedRest || iv->iVararg; 
  468. } 
  469.  
  470. imeth char * Prototype_im_gLastArg(object self)
  471. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  472.     return iv->iLastArg && !iv->iVararg ? gStringValue(iv->iLastArg) : "self"; 
  473. } 
  474.  
  475. imeth objrtn Prototype_im_gException(object self)
  476. { Prototype_iv_t *iv = GetIVs(Prototype, self);
  477.     iv->iException = 1; 
  478.     return self; 
  479. } 
  480.  
  481.  
  482. #line 483 "proto.c"
  483.  
  484. objrtn    Prototype_initialize(void)
  485. {
  486.     static  CRITICALSECTION  cs;
  487.     static  int volatile once = 0;
  488.  
  489.     ENTERCRITICALSECTION(_CI_CS_);
  490.     if (!once) {
  491.         INITIALIZECRITICALSECTION(cs);
  492.         once = 1;
  493.     }
  494.     LEAVECRITICALSECTION(_CI_CS_);
  495.  
  496.     ENTERCRITICALSECTION(cs);
  497.  
  498.     if (Prototype_c) {
  499.         LEAVECRITICALSECTION(cs);
  500.         return Prototype_c;
  501.     }
  502.     INHIBIT_THREADER;
  503.     Prototype_c = gNewClass(Class, "Prototype", sizeof(Prototype_iv_t), 0, END);
  504.     cMethodFor(Prototype, gNew, Prototype_cm_gNew);
  505.     cMethodFor(Prototype, gNewWithStrStr, Prototype_cm_gNewWithStrStr);
  506.     iMethodFor(Prototype, gMatch, Prototype_im_gMatch);
  507.     iMethodFor(Prototype, gChangeFixedName, Prototype_im_gChangeFixedName);
  508.     iMethodFor(Prototype, gLastArg, Prototype_im_gLastArg);
  509.     iMethodFor(Prototype, gChangeName, Prototype_im_gChangeName);
  510.     iMethodFor(Prototype, gArgs, Prototype_im_gArgs);
  511.     iMethodFor(Prototype, gMatchNoError, Prototype_im_gMatchNoError);
  512.     iMethodFor(Prototype, gPrintMethArgs, Prototype_im_gPrintMethArgs);
  513.     iMethodFor(Prototype, gGetFixedName, Prototype_im_gGetFixedName);
  514.     iMethodFor(Prototype, gGetMGName, Prototype_im_gGetMGName);
  515.     iMethodFor(Prototype, gCompare, Prototype_im_gCompare);
  516.     iMethodFor(Prototype, gPrototype, Prototype_im_gPrototype);
  517.     iMethodFor(Prototype, gPrintVars, Prototype_im_gPrintVars);
  518.     iMethodFor(Prototype, gSetArgs, Prototype_im_gSetArgs);
  519.     iMethodFor(Prototype, gDispose, Prototype_im_gDispose);
  520.     iMethodFor(Prototype, gPrintArgs, Prototype_im_gPrintArgs);
  521.     iMethodFor(Prototype, gParameters, Prototype_im_gParameters);
  522.     iMethodFor(Prototype, gPrintFixedArgs, Prototype_im_gPrintFixedArgs);
  523.     iMethodFor(Prototype, gReturnType, Prototype_im_gReturnType);
  524.     iMethodFor(Prototype, gIsVarArg, Prototype_im_gIsVarArg);
  525.     iMethodFor(Prototype, gHash, Prototype_im_gHash);
  526.     iMethodFor(Prototype, gUseVars, Prototype_im_gUseVars);
  527.     iMethodFor(Prototype, gDeepDispose, Prototype_im_gDispose);
  528.     iMethodFor(Prototype, gVarArg, Prototype_im_gVarArg);
  529.     iMethodFor(Prototype, gException, Prototype_im_gException);
  530.     iMethodFor(Prototype, gDeepCopy, Prototype_im_gDeepCopy);
  531.  
  532.     ENABLE_THREADER;
  533.  
  534.     LEAVECRITICALSECTION(cs);
  535.  
  536.     return Prototype_c;
  537. }
  538.  
  539.  
  540.  
  541.